home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / bn_art1.c next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  21.9 KB  |  894 lines
  1. /*****************************************************************************
  2.   FILE           : bn_art1.c
  3.   SHORTNAME      : bn_art1
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : Creates the ART1-window and ART1 networks.
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Kai-Uwe Herrmann
  10.   DATE           : 15.1.1993
  11.  
  12.   CHANGED BY     : 
  13.   IDENTIFICATION : @(#)bn_art1.c    1.8 3/2/94
  14.   SCCS VERSION   : 1.8
  15.   LAST CHANGE    : 3/2/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20.  
  21.  
  22.  
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <X11/Xlib.h>
  26. #include <X11/Xutil.h>
  27. #include <X11/Xos.h>
  28. #include <X11/cursorfont.h>
  29. #include <X11/Intrinsic.h>
  30. #include <X11/StringDefs.h>
  31. #include <X11/Shell.h>
  32. #include <X11/Xaw/Box.h>
  33. #include <X11/Xaw/Simple.h>
  34. #include <X11/Xaw/Grip.h>
  35. #include <X11/Xaw/Form.h>
  36. #include <X11/Xaw/SmeBSB.h>
  37. #include <X11/Xaw/SmeLine.h>
  38. #include <X11/Xaw/Viewport.h>
  39. #include <X11/Xaw/Label.h>
  40. #include <X11/Xaw/Toggle.h>
  41. #include <X11/Xaw/Command.h>
  42. #include <X11/Xaw/Cardinals.h>
  43. #include <X11/Xaw/AsciiText.h>
  44. #include <X11/Xaw/Scrollbar.h>
  45.  
  46. #include "ui.h"
  47. #include "glob_typ.h"
  48. #include "kr_ui.h"
  49. #include "ui_mainP.h"
  50. #include "ui_confirmer.h"
  51. #include "ui_textP.h"
  52. #include "ui_utilP.h"
  53. #include "ui_netUpdate.h"
  54. #include "ui_status.h"
  55. #include "ui_xWidgets.h"
  56. #include "ui_fileP.h"
  57. #include "ui_display.h"
  58. #include "ui_event.h"
  59. #include "ui_selection.h"
  60.  
  61.  
  62. #include "bn_basics.h"
  63.  
  64. #include "bn_art1.ph"
  65.  
  66.  
  67.  
  68.  
  69. /*****************************************************************************
  70.   FUNCTION : bn_art1_createNet
  71.  
  72.   PURPOSE  : Generation of the ART1 network using SNNS kernel functions.
  73.   NOTES    :
  74.  
  75.   UPDATE   : 20.1.1993
  76. ******************************************************************************/
  77.  
  78. static krui_err bn_art1_createNet (int IUnits, int IRow, int CUnits, int CRow)
  79.  
  80. {
  81.   krui_err          ret_code                   = KRERR_NO_ERROR;
  82.   int               i, j, unit_no;
  83.  
  84.   int               ICol, CCol,
  85.                     Row, Col, NoOfUnitsPerRow;
  86.  
  87.   int               RowOffset, ColOffset;
  88.  
  89.   struct PosType    unit_pos;
  90.  
  91.   char              name[10];
  92.  
  93.  
  94.   ICol = NoOfUnitsPerRow = ((int) (IUnits/IRow) + POS_SIGN(IUnits % IRow));
  95.  
  96.  
  97.   /*  Create Input Units  */
  98.   Col = 1;
  99.   Row = 1;
  100.   RowOffset = 4;
  101.   ColOffset = 1;
  102.   for (i = 1; i <= IUnits; i++)
  103.     {
  104.  
  105.     unit_no = krui_createDefaultUnit();
  106.     if (unit_no < 0)  CHECK_RETURN( unit_no );
  107.     ret_code = krui_setUnitTType( unit_no, INPUT );
  108.     CHECK_RETURN( ret_code );
  109.     ret_code = krui_setUnitActFunc(unit_no, ART1_ACTF_INP);
  110.     CHECK_RETURN (ret_code);
  111.     ret_code = krui_setUnitOutFunc(unit_no, ART1_OUTFUNC);
  112.     CHECK_RETURN (ret_code);
  113.     sprintf (name,"%s%d","inp",i);
  114.     ret_code = krui_setUnitName (unit_no, name);
  115.     CHECK_RETURN (ret_code);
  116.  
  117.     unit_pos.x = Col + ColOffset;
  118.     unit_pos.y = Row + RowOffset;
  119.     krui_setUnitPosition( unit_no, &unit_pos );
  120.  
  121.     if ( (ICol == Col) ||
  122.          ((IUnits%IRow != 0) && (Row != IRow) && 
  123.           ((IUnits-i)%(IRow-Row) == 0) && (Col == ICol-1)
  124.          )
  125.        ) 
  126.     {
  127.       Row++;
  128.       Col = 1;
  129.     } else {
  130.       Col++;
  131.     } /*if*/
  132.  
  133.   }
  134.  
  135.   /*  Create Comparison Layer Units */
  136.  
  137.   RowOffset = 4;
  138.   ColOffset = ICol + 2;
  139.   Row = 1;
  140.   Col = 1;
  141.  
  142.   for (i = 1; i <= IUnits; i++)
  143.     {
  144.     unit_no = krui_createDefaultUnit();
  145.     if (unit_no < 0)  CHECK_RETURN( unit_no );
  146.     ret_code = krui_setUnitTType( unit_no, HIDDEN );
  147.     CHECK_RETURN( ret_code );
  148.     ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_CMP);
  149.     CHECK_RETURN (ret_code);
  150.     ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  151.     CHECK_RETURN (ret_code);
  152.     sprintf (name,"%s%d","cmp",i);
  153.     ret_code = krui_setUnitName (unit_no, name);
  154.     CHECK_RETURN (ret_code);
  155.  
  156.     unit_pos.x = Col + ColOffset;
  157.     unit_pos.y = Row + RowOffset;
  158.     krui_setUnitPosition( unit_no, &unit_pos );
  159.  
  160.     if ( (ICol == Col) ||
  161.          ((IUnits%IRow != 0) && (Row != IRow) && 
  162.           ((IUnits-i)%(IRow-Row) == 0) && (Col == ICol-1)
  163.          )
  164.        ) 
  165.     {
  166.       Row++;
  167.       Col = 1;
  168.     } else {
  169.       Col++;
  170.     } /*if*/
  171.  
  172.   }
  173.  
  174.   CCol = NoOfUnitsPerRow = ((int) (CUnits/CRow) + POS_SIGN(CUnits % CRow));
  175.  
  176.  
  177.   /*  Create Recognition layer units */
  178.  
  179.   RowOffset = 4;
  180.   ColOffset = 2 * ICol + 5;
  181.   Row = 1;
  182.   Col = 1;
  183.  
  184.   unit_pos.x = 10;
  185.   for (i = 1; i <= CUnits; i++)
  186.     {
  187.     unit_no = krui_createDefaultUnit();
  188.     if (unit_no < 0)  CHECK_RETURN( unit_no );
  189.     ret_code = krui_setUnitTType( unit_no, SPECIAL );
  190.     CHECK_RETURN( ret_code );
  191.     ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_REC);
  192.     CHECK_RETURN (ret_code);
  193.     ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  194.     CHECK_RETURN (ret_code);
  195.     sprintf (name,"%s%d","rec",i);
  196.     ret_code = krui_setUnitName (unit_no, name);
  197.     CHECK_RETURN (ret_code);
  198.  
  199.     unit_pos.x = Col + ColOffset;
  200.     unit_pos.y = Row + RowOffset;
  201.     krui_setUnitPosition( unit_no, &unit_pos );
  202.  
  203.     if ( (CCol == Col) ||
  204.          ((CUnits%CRow != 0) && (Row != CRow) && 
  205.           ((CUnits-i)%(CRow-Row) == 0) && (Col == CCol-1)
  206.          )
  207.        ) 
  208.     {
  209.       Row++;
  210.       Col = 1;
  211.     } else {
  212.       Col++;
  213.     } /*if*/
  214.  
  215.   }
  216.  
  217.  
  218.   /*  Create Delay layer units that correspond to a recognition unit */
  219.  
  220.   RowOffset = 4;
  221.   ColOffset = 2 * ICol + CCol + 6;
  222.   Row = 1;
  223.   Col = 1;
  224.  
  225.   for (i = 1; i <= CUnits; i++)
  226.     {
  227.     unit_no = krui_createDefaultUnit();
  228.     if (unit_no < 0)  CHECK_RETURN( unit_no );
  229.     ret_code = krui_setUnitTType( unit_no, HIDDEN );
  230.     CHECK_RETURN( ret_code );
  231.     ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_DEL);
  232.     CHECK_RETURN (ret_code);
  233.     ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  234.     CHECK_RETURN (ret_code);
  235.     sprintf (name,"%s%d","del",i);
  236.     ret_code = krui_setUnitName (unit_no, name);
  237.     CHECK_RETURN (ret_code);
  238.  
  239.     unit_pos.x = Col + ColOffset;
  240.     unit_pos.y = Row + RowOffset;
  241.     krui_setUnitPosition( unit_no, &unit_pos );
  242.  
  243.     if ( (CCol == Col) ||
  244.          ((CUnits%CRow != 0) && (Row != CRow) && 
  245.           ((CUnits-i)%(CRow-Row) == 0) && (Col == CCol-1)
  246.          )
  247.        ) 
  248.     {
  249.       Row++;
  250.       Col = 1;
  251.     } else {
  252.       Col++;
  253.     } /*if*/
  254.  
  255.   }
  256.  
  257.   /* Create d1 unit */
  258.   RowOffset = 1;
  259.   ColOffset = 2 * ICol + CCol + 6;
  260.   Row = 1;
  261.   Col = 1;
  262.   unit_no = krui_createDefaultUnit();
  263.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  264.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  265.   CHECK_RETURN( ret_code );
  266.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_D);
  267.   CHECK_RETURN (ret_code);
  268.   ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  269.   CHECK_RETURN (ret_code);
  270.   ret_code = krui_setUnitName (unit_no, "d1");
  271.   CHECK_RETURN (ret_code);
  272.  
  273.   unit_pos.x = Col + ColOffset;
  274.   unit_pos.y = Row + RowOffset;
  275.   krui_setUnitPosition( unit_no, &unit_pos );
  276.  
  277.   /* Create d2 unit */
  278.   RowOffset = 1;
  279.   ColOffset = 2 * ICol + 2* CCol + 7;
  280.   Row = 1;
  281.   Col = 1;
  282.   unit_no = krui_createDefaultUnit();
  283.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  284.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  285.   CHECK_RETURN( ret_code );
  286.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_D);
  287.   CHECK_RETURN (ret_code);
  288.   ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  289.   CHECK_RETURN (ret_code);
  290.   ret_code = krui_setUnitName (unit_no, "d2");
  291.   CHECK_RETURN (ret_code);
  292.  
  293.   unit_pos.x = Col + ColOffset;
  294.   unit_pos.y = Row + RowOffset;
  295.   krui_setUnitPosition( unit_no, &unit_pos );
  296.  
  297.   /* Create d3 unit */
  298.   RowOffset = 1;
  299.   ColOffset = 2 * ICol + 3 * CCol + 9;
  300.   Row = 1;
  301.   Col = 1;
  302.   unit_no = krui_createDefaultUnit();
  303.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  304.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  305.   CHECK_RETURN( ret_code );
  306.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_D);
  307.   CHECK_RETURN (ret_code);
  308.   ret_code = krui_setUnitOutFunc (unit_no, ART1_OUTFUNC);
  309.   CHECK_RETURN (ret_code);
  310.   ret_code = krui_setUnitName (unit_no, "d3");
  311.   CHECK_RETURN (ret_code);
  312.  
  313.   unit_pos.x = Col + ColOffset;
  314.   unit_pos.y = Row + RowOffset;
  315.   krui_setUnitPosition( unit_no, &unit_pos );
  316.  
  317.   /*  Create Reset layer units */
  318.  
  319.   RowOffset = 4;
  320.   ColOffset = 2*ICol + 2*CCol + 7;
  321.   Row = 1;
  322.   Col = 1;
  323.  
  324.   /* Create Site Table Entries for Reset layer units */
  325.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_RST_SELF,
  326.                        ART1_SITE_FUNC_RST_SELF);
  327.   CHECK_RETURN (ret_code);
  328.  
  329.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_RST_SIGNAL,
  330.                        ART1_SITE_FUNC_RST_SIGNAL);
  331.   CHECK_RETURN (ret_code);
  332.  
  333.  
  334.   for (i = 1; i <= CUnits; i++)
  335.     {
  336.     unit_no = krui_createDefaultUnit();
  337.     if (unit_no < 0)  CHECK_RETURN( unit_no );
  338.     ret_code = krui_setUnitTType( unit_no, HIDDEN );
  339.     CHECK_RETURN( ret_code );
  340.     ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_RST);
  341.     CHECK_RETURN (ret_code);
  342.     sprintf (name,"%s%d","rst",i);
  343.     ret_code = krui_setUnitName (unit_no, name);
  344.     CHECK_RETURN (ret_code);
  345.  
  346.     unit_pos.x = Col + ColOffset;
  347.     unit_pos.y = Row + RowOffset;
  348.     krui_setUnitPosition( unit_no, &unit_pos );
  349.  
  350.     if ( (CCol == Col) ||
  351.          ((CUnits%CRow != 0) && (Row != CRow) && 
  352.           ((CUnits-i)%(CRow-Row) == 0) && (Col == CCol-1)
  353.          )
  354.        ) 
  355.     {
  356.       Row++;
  357.       Col = 1;
  358.     } else {
  359.       Col++;
  360.     } /*if*/
  361.  
  362.     ret_code = krui_setCurrentUnit (unit_no);
  363.     CHECK_RETURN (ret_code);
  364.  
  365.     /* Add the two Sites */
  366.     ret_code = krui_addSite (ART1_SITE_NAME_RST_SELF);
  367.     CHECK_RETURN (ret_code);
  368.     ret_code = krui_addSite (ART1_SITE_NAME_RST_SIGNAL);
  369.     CHECK_RETURN (ret_code);
  370.   }
  371.  
  372.  
  373.  
  374.  
  375.   /*  Create Gain1 unit */
  376.  
  377.   /* Create Site Table Entries for the two Sites */
  378.  
  379.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_REC_G1,
  380.                                          ART1_SITE_FUNC_REC_G1);
  381.   CHECK_RETURN (ret_code);
  382.  
  383.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_INP_G1,
  384.                                          ART1_SITE_FUNC_INP_G1);
  385.   CHECK_RETURN (ret_code);
  386.  
  387.   ColOffset = ICol + 2 + (int) ICol/2;
  388.   RowOffset = 1;
  389.   Col = 1;
  390.   Row = 1;
  391.  
  392.   unit_no = krui_createDefaultUnit();
  393.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  394.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  395.   CHECK_RETURN( ret_code );
  396.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_G1);
  397.   CHECK_RETURN (ret_code);
  398.   ret_code = krui_setUnitName (unit_no, "g1");
  399.   CHECK_RETURN (ret_code);
  400.  
  401.   unit_pos.x = Col + ColOffset;
  402.   unit_pos.y = Row + RowOffset;
  403.   krui_setUnitPosition( unit_no, &unit_pos );
  404.  
  405.  
  406.   ret_code = krui_setCurrentUnit (unit_no);
  407.   CHECK_RETURN (ret_code);
  408.  
  409.   /* Add the two Sites */
  410.   ret_code = krui_addSite (ART1_SITE_NAME_INP_G1);
  411.   CHECK_RETURN (ret_code);
  412.   ret_code = krui_addSite (ART1_SITE_NAME_REC_G1);
  413.   CHECK_RETURN (ret_code);
  414.  
  415.  
  416.   ColOffset = 1;
  417.   RowOffset = 4 + IRow + 2;
  418.   Col = 1;
  419.   Row = 1;
  420.  
  421.   /*  Create ResetI unit */
  422.  
  423.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_INP_RI,
  424.                                          ART1_SITE_FUNC_INP_RI);
  425.   CHECK_RETURN (ret_code);
  426.  
  427.   ret_code = krui_createSiteTableEntry (ART1_SITE_NAME_RHO_RI,
  428.                                          ART1_SITE_FUNC_RHO_RI);
  429.   CHECK_RETURN (ret_code);
  430.  
  431.   unit_no = krui_createDefaultUnit();
  432.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  433.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  434.   CHECK_RETURN( ret_code );
  435.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_RI);
  436.   CHECK_RETURN (ret_code);
  437.   ret_code = krui_setUnitName (unit_no, "ri");
  438.   CHECK_RETURN (ret_code);
  439.  
  440.   unit_pos.x = Col + ColOffset;
  441.   unit_pos.y = Row + RowOffset;
  442.   krui_setUnitPosition( unit_no, &unit_pos );
  443.  
  444.   ret_code = krui_setCurrentUnit (unit_no);
  445.   CHECK_RETURN (ret_code);
  446.  
  447.   /* Add the two Sites */
  448.   ret_code = krui_addSite (ART1_SITE_NAME_INP_RI);
  449.   CHECK_RETURN (ret_code);
  450.   ret_code = krui_addSite (ART1_SITE_NAME_RHO_RI);
  451.   CHECK_RETURN (ret_code);
  452.  
  453.  
  454.   ColOffset = ICol + 2;
  455.   RowOffset = 4 + IRow + 2;
  456.   Col = 1;
  457.   Row = 1;
  458.  
  459.   /*  Create ResetC unit */
  460.   unit_no = krui_createDefaultUnit();
  461.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  462.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  463.   CHECK_RETURN( ret_code );
  464.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_RC);
  465.   CHECK_RETURN (ret_code);
  466.   ret_code = krui_setUnitName (unit_no, "rc");
  467.   CHECK_RETURN (ret_code);
  468.  
  469.   unit_pos.x = Col + ColOffset;
  470.   unit_pos.y = Row + RowOffset;
  471.   krui_setUnitPosition( unit_no, &unit_pos );
  472.  
  473.   ColOffset = 2 * ICol + 5;
  474.   RowOffset = 4 + CRow + 2;
  475.   Col = 1;
  476.   Row = 1;
  477.  
  478.   /*  Create Reset general unit */
  479.   unit_no = krui_createDefaultUnit();
  480.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  481.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  482.   CHECK_RETURN( ret_code );
  483.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_RG);
  484.   CHECK_RETURN (ret_code);
  485.   ret_code = krui_setUnitName (unit_no, "rg");
  486.   CHECK_RETURN (ret_code);
  487.  
  488.   unit_pos.x = Col + ColOffset;
  489.   unit_pos.y = Row + RowOffset;
  490.   krui_setUnitPosition( unit_no, &unit_pos );
  491.  
  492.  
  493.  
  494.   ColOffset = 2 * ICol + 3 * CCol + 9;
  495.   RowOffset = 4 + (int) CRow/3;
  496.   Row = 1;
  497.   Col = 1;
  498.  
  499.   /*  Create Classified unit */
  500.   unit_no = krui_createDefaultUnit();
  501.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  502.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  503.   CHECK_RETURN( ret_code );
  504.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_CL);
  505.   CHECK_RETURN (ret_code);
  506.   ret_code = krui_setUnitName (unit_no, "cl");
  507.   CHECK_RETURN (ret_code);
  508.  
  509.   unit_pos.x = Col + ColOffset;
  510.   unit_pos.y = Row + RowOffset;
  511.   krui_setUnitPosition( unit_no, &unit_pos );
  512.  
  513.  
  514.   ColOffset = 2 * ICol + 3 * CCol + 9;
  515.   RowOffset = 4 + 2 * (int) CRow/3;
  516.   Row = 1;
  517.   Col = 1;
  518.  
  519.   /*  Create Not Classifiable unit */
  520.  
  521.   unit_no = krui_createDefaultUnit();
  522.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  523.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  524.   CHECK_RETURN( ret_code );
  525.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_NCL);
  526.   CHECK_RETURN (ret_code);
  527.   ret_code = krui_setUnitName (unit_no, "nc");
  528.   CHECK_RETURN (ret_code);
  529.  
  530.   unit_pos.x = Col + ColOffset;
  531.   unit_pos.y = Row + RowOffset;
  532.   krui_setUnitPosition( unit_no, &unit_pos );
  533.  
  534.  
  535.   ColOffset = 1;
  536.   RowOffset = 4 + IRow + 4;
  537.   Col = 1;
  538.   Row = 1;
  539.  
  540.   /*  Create RHO unit */
  541.   unit_no = krui_createDefaultUnit();
  542.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  543.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  544.   CHECK_RETURN( ret_code );
  545.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_RHO);
  546.   CHECK_RETURN (ret_code);
  547.   ret_code = krui_setUnitName (unit_no, "rho");
  548.   CHECK_RETURN (ret_code);
  549.  
  550.   unit_pos.x = Col + ColOffset;
  551.   unit_pos.y = Row + RowOffset;
  552.   krui_setUnitPosition( unit_no, &unit_pos );
  553.  
  554.  
  555.   RowOffset = 1;
  556.   ColOffset = 2 * ICol + 5;
  557.   Row = 1;
  558.   Col = 1;
  559.  
  560.   /*  Create G2 unit */
  561.   unit_no = krui_createDefaultUnit();
  562.   if (unit_no < 0)  CHECK_RETURN( unit_no );
  563.   ret_code = krui_setUnitTType( unit_no, HIDDEN );
  564.   CHECK_RETURN( ret_code );
  565.   ret_code = krui_setUnitActFunc (unit_no, ART1_ACTF_G2);
  566.   CHECK_RETURN (ret_code);
  567.   ret_code = krui_setUnitName (unit_no, "g2");
  568.   CHECK_RETURN (ret_code);
  569.  
  570.   unit_pos.x = Col + ColOffset;
  571.   unit_pos.y = Row + RowOffset;
  572.   krui_setUnitPosition( unit_no, &unit_pos );
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579.   /* Make Connections now */
  580.  
  581.  
  582.   /* Connections to comparison units */
  583.   FOR_ALL_ART1_CMP_UNITS (i) {
  584.     ret_code = krui_setCurrentUnit (i);
  585.     CHECK_RETURN( ret_code );
  586.  
  587.     /* from input units */
  588.     ret_code = krui_createLink ((i-IUnits), 0.0);
  589.     CHECK_RETURN( ret_code );
  590.  
  591.     /* from delay units */
  592.     FOR_ALL_ART1_DEL_UNITS (j) {
  593.        ret_code = krui_createLink (j,0.0);
  594.        CHECK_RETURN (ret_code);
  595.     }
  596.  
  597.     /* from g1 unit */
  598.     ret_code = krui_createLink (G1_UNIT, 0.0);
  599.  
  600.   }
  601.  
  602.   /* Connections to recognition units */
  603.   FOR_ALL_ART1_REC_UNITS (i) {
  604.      ret_code = krui_setCurrentUnit (i);
  605.      CHECK_RETURN (ret_code);
  606.  
  607.      /* from comparison units */
  608.      FOR_ALL_ART1_CMP_UNITS (j) {
  609.         ret_code = krui_createLink (j,0.0);
  610.         CHECK_RETURN (ret_code);
  611.      }
  612.  
  613.      /* from reset units */
  614.      ret_code = krui_createLink ((i+2*CUnits+3), 0.0);
  615.      CHECK_RETURN (ret_code);
  616.  
  617.      /* from reset general unit */
  618.      ret_code = krui_createLink (RG_UNIT, 0.0);
  619.      CHECK_RETURN (ret_code);
  620.  
  621.      /* from gain 2 unit */
  622.      ret_code = krui_createLink (G2_UNIT, 0.0);
  623.      CHECK_RETURN (ret_code);
  624.   }
  625.  
  626.   /* Connections to delay units */
  627.   FOR_ALL_ART1_DEL_UNITS (i) {
  628.      ret_code = krui_setCurrentUnit (i);
  629.      CHECK_RETURN (ret_code);
  630.  
  631.      /* from recognition units */
  632.      ret_code = krui_createLink ((i-CUnits), 0.0);
  633.      CHECK_RETURN (ret_code);
  634.   }
  635.  
  636.   /* Connections to local reset units */
  637.   FOR_ALL_ART1_RST_UNITS (i) {
  638.      ret_code = krui_setCurrentUnit (i);
  639.      CHECK_RETURN (ret_code);
  640.  
  641.      /* from itself */
  642.      ret_code = krui_setSite (ART1_SITE_NAME_RST_SELF);
  643.      CHECK_RETURN (ret_code);
  644.      ret_code = krui_createLink (i, 0.0);
  645.      CHECK_RETURN (ret_code);
  646.  
  647.      /* from delay units */
  648.      ret_code = krui_setSite (ART1_SITE_NAME_RST_SIGNAL);
  649.      CHECK_RETURN (ret_code);
  650.      ret_code = krui_createLink ((i-CUnits-3), 0.0);
  651.      CHECK_RETURN (ret_code);
  652.  
  653.      /* from reset general unit */
  654.      ret_code = krui_createLink (RG_UNIT, 0.0);
  655.      CHECK_RETURN (ret_code);
  656.   }
  657.  
  658.  
  659.   /* Connections to units d1-d3 */
  660.  
  661.   /* d1 */
  662.   ret_code = krui_setCurrentUnit (D_UNIT (1));
  663.   CHECK_RETURN (ret_code);
  664.  
  665.   /* from all delay units */
  666.   FOR_ALL_ART1_DEL_UNITS (j) {
  667.      ret_code = krui_createLink (j, 0.0);
  668.      CHECK_RETURN (ret_code);
  669.   }
  670.  
  671.   /* d2 */
  672.   ret_code = krui_setCurrentUnit (D_UNIT (2));
  673.   CHECK_RETURN (ret_code);
  674.  
  675.   /* from d1 */
  676.   ret_code = krui_createLink (D_UNIT (1), 0.0);
  677.   CHECK_RETURN (ret_code);
  678.  
  679.   /* d3 */
  680.   ret_code = krui_setCurrentUnit (D_UNIT (3));
  681.   CHECK_RETURN (ret_code);
  682.  
  683.   /* from d2 */
  684.   ret_code = krui_createLink (D_UNIT (2), 0.0);
  685.   CHECK_RETURN (ret_code);
  686.  
  687.  
  688.   /* connections to gain 1 unit */
  689.   ret_code = krui_setCurrentUnit (G1_UNIT);
  690.   CHECK_RETURN (ret_code);
  691.  
  692.   /* from input units */
  693.   ret_code = krui_setSite (ART1_SITE_NAME_INP_G1);
  694.   CHECK_RETURN (ret_code);
  695.   FOR_ALL_ART1_INP_UNITS (j) {
  696.      ret_code = krui_createLink (j, 0.0);
  697.      CHECK_RETURN (ret_code);
  698.   }
  699.  
  700.   /* from recognition units */
  701.   ret_code = krui_setSite (ART1_SITE_NAME_REC_G1);
  702.   CHECK_RETURN (ret_code);
  703.   FOR_ALL_ART1_REC_UNITS (j) {
  704.      ret_code = krui_createLink (j, 0.0);
  705.      CHECK_RETURN (ret_code);
  706.   }
  707.  
  708.  
  709.   /* connections to ResetI unit */
  710.   ret_code = krui_setCurrentUnit (RI_UNIT);
  711.   CHECK_RETURN (ret_code);
  712.  
  713.   /* Site for input units */
  714.   ret_code = krui_setSite (ART1_SITE_NAME_INP_RI);
  715.   CHECK_RETURN (ret_code);
  716.  
  717.   /* from input units */
  718.   FOR_ALL_ART1_INP_UNITS (j) {
  719.      ret_code = krui_createLink (j, 0.0);
  720.      CHECK_RETURN (ret_code);
  721.   }
  722.  
  723.   /* Site for Unit RHO */
  724.   ret_code = krui_setSite (ART1_SITE_NAME_RHO_RI);
  725.   CHECK_RETURN (ret_code);
  726.  
  727.   /* from RHO unit */
  728.   ret_code = krui_createLink (RHO_UNIT, 0.0);
  729.   CHECK_RETURN (ret_code);
  730.  
  731.  
  732.   /* connections to ResetC unit */
  733.   ret_code = krui_setCurrentUnit (RC_UNIT);
  734.   CHECK_RETURN (ret_code);
  735.  
  736.   /* from comparison units */
  737.   FOR_ALL_ART1_CMP_UNITS (j) {
  738.      ret_code = krui_createLink (j, 0.0);
  739.      CHECK_RETURN (ret_code);
  740.   }
  741.  
  742.  
  743.   /* connections to reset general unit */
  744.   ret_code = krui_setCurrentUnit (RG_UNIT);
  745.   CHECK_RETURN (ret_code);
  746.  
  747.   /* from ResetI unit */
  748.   ret_code = krui_createLink (RI_UNIT, 0.0);
  749.   CHECK_RETURN (ret_code);
  750.  
  751.   /* from ResetC unit */
  752.   ret_code = krui_createLink (RC_UNIT, 0.0);
  753.   CHECK_RETURN (ret_code);
  754.  
  755.  
  756.   /* connections to Classified unit */
  757.   ret_code = krui_setCurrentUnit (CL_UNIT);
  758.   CHECK_RETURN (ret_code);
  759.  
  760.   /* from d3 unit */
  761.   ret_code = krui_createLink (D_UNIT (3), 0.0);
  762.   CHECK_RETURN (ret_code);
  763.  
  764.   /* from reset general unit */
  765.   ret_code = krui_createLink (RG_UNIT, 0.0);
  766.   CHECK_RETURN (ret_code);
  767.  
  768.   /* from gain 2 unit */
  769.   ret_code = krui_createLink (G2_UNIT, 0.0);
  770.   CHECK_RETURN (ret_code);
  771.  
  772.  
  773.   /* connections to Not Classifiable unit */
  774.   ret_code = krui_setCurrentUnit (NCL_UNIT);
  775.   CHECK_RETURN (ret_code);
  776.  
  777.   /* from local reset units */
  778.   FOR_ALL_ART1_RST_UNITS (j) {
  779.      ret_code = krui_createLink (j, 0.0);
  780.      CHECK_RETURN (ret_code);
  781.   }
  782.  
  783.   /* connections to RHO unit */
  784.   ret_code = krui_setCurrentUnit (RHO_UNIT);
  785.   CHECK_RETURN (ret_code);
  786.  
  787.   /* from itself */
  788.   ret_code = krui_createLink (RHO_UNIT, 0.0);
  789.   CHECK_RETURN (ret_code);
  790.  
  791.  
  792.   /* connections to G2 unit */
  793.   ret_code = krui_setCurrentUnit (G2_UNIT);
  794.   CHECK_RETURN (ret_code);
  795.  
  796.   /* from input units */
  797.   FOR_ALL_ART1_INP_UNITS (j) {
  798.      ret_code = krui_createLink (j, 0.0);
  799.      CHECK_RETURN (ret_code);
  800.   } /*FOR_ALL_ART1_INP_UNITS*/
  801.  
  802.  
  803.  
  804.  
  805.   /*  set the update function  */
  806.   ret_code = krui_setUpdateFunc (ART1_UPDATE_FUNC_NAME);
  807.   CHECK_RETURN( ret_code );
  808.  
  809.   /* set the learning function */
  810.   ret_code = krui_setLearnFunc (ART1_LEARN_FUNC_NAME);
  811.  
  812.   return (ret_code);
  813.  
  814. } /* bn_art1_createNet () */
  815.  
  816.  
  817.  
  818.  
  819.  
  820.  
  821. /*****************************************************************************
  822.   FUNCTION : bn_art1_donePROC
  823.  
  824.   PURPOSE  : Callback function for DONE button in art1
  825.   NOTES    :
  826.  
  827.   UPDATE   : 20.1.1993
  828. ******************************************************************************/
  829.  
  830. static void bn_art1_donePROC (void)
  831.  
  832. {
  833.  
  834.    XtDestroyWidget (baseWidget);
  835.    bn_art1_open = 0;
  836.  
  837. }
  838.  
  839.  
  840.  
  841. /*****************************************************************************
  842.   FUNCTION : bn_art1_createPROC
  843.  
  844.   PURPOSE  : Callback function for CREATE NET button in art1
  845.   NOTES    :
  846.  
  847.   UPDATE   : 20.1.1993
  848. ******************************************************************************/
  849.  
  850. static void bn_art1_createPROC (void)
  851.  
  852. {
  853.   int units[2], rows[2];
  854.   int NoOfLayers = 2;
  855.  
  856.   if (bn_basics_check_existingNetwork()) {
  857.  
  858.      bn_basics_getValues (NoOfLayers, units, rows, art1UnitWidget, art1RowWidget);
  859.  
  860.      if (bn_basics_checkValues(NoOfLayers, units, rows)) {
  861.         bn_art1_createNet (units[0], rows[0], units[1], rows[1]);
  862.         bn_basics_refresh ();
  863.         ui_confirmOk ("Network created!");
  864.      } /*if*/
  865.  
  866.   } /*if*/
  867.  
  868.   return;
  869.  
  870. }
  871.  
  872.  
  873.  
  874. /*****************************************************************************
  875.   FUNCTION : bn_createART1
  876.  
  877.   PURPOSE  : create ART1 panel
  878.   NOTES    :
  879.  
  880.   UPDATE   : 20.1.1993
  881. ******************************************************************************/
  882.  
  883. void bn_createART1(void)
  884.  
  885. {
  886.   bn_basics_createART (ART1_MODEL, &baseWidget, &bn_art1_open,
  887.                        art1UnitWidget, art1RowWidget,
  888.                        (XtCallbackProc) bn_art1_createPROC,
  889.                        (XtCallbackProc) bn_art1_donePROC);
  890.  
  891.  
  892. }
  893.  
  894.